/*****************************************************************************
 * Source code information
 * -----------------------
 * Original author    Myriam Leggieri
 * Author email       myriam.leggieri@gmail.com
 * Package            @package@
 * Web site           @website@
 * Created            17 Jun 2009 14:24
 * Filename           $RCSfile $
 * Revision           $Revision$
 * Release status     @releaseStatus@ $State: Exp $
 *
 * Last modified on   $Date: 2009/06/05 11:46:00 $
 *               by   $Author: myriam $
 *
 * @copyright@
 *****************************************************************************/

// Package
///////////////////////////////////////
package org.hackystat.linkedservicedata.vocabularies;

// Imports
///////////////////////////////////////
import com.hp.hpl.jena.rdf.model.*;
import com.hp.hpl.jena.ontology.*;

/**
 * Vocabulary definitions from
 * /home/myrtill/Hackystat_linkedData/mysqlProva/workspace/hackystat-linked
 * -service-data/src/org/hackystat/linkedservicedata/vocabularies/Process.owl
 *
 * @author Auto-generated by schemagen on 17 Jun 2009 14:24
 */
public class ProcessVocab {
  /**
   * <p>
   * The ontology model that holds the vocabulary terms
   * </p>
   */
  private static OntModel m_model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, null);

  /**
   * <p>
   * The namespace of the vocabulary as a string
   * </p>
   */
  public static final String NS = "http://www.daml.org/services/owl-s/1.1/Process.owl#";

  public static final String PREFIX = "owls";

  /**
   * <p>
   * The namespace of the vocabulary as a string
   * </p>
   *
   * @see #NS
   */
  public static String getURI() {
    return NS;
  }

  /**
   * <p>
   * The namespace of the vocabulary as a resource
   * </p>
   */
  public static final Resource NAMESPACE = m_model.createResource(NS);

  // Vocabulary properties
  // /////////////////////////

  /**
   * <p>
   * This is a deprecated usage; collapsesTo is preferred.
   * </p>
   */
  public static final ObjectProperty COLLAPSE = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#collapse");

  public static final ObjectProperty COLLAPSES_TO = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#collapsesTo");

  /**
   * <p>
   * The components propery of selected control construct subclasses holds a specific arrangement of
   * subprocesses or control constructs. The range is declared at each relevant subclass of
   * ControlConstruct.
   * </p>
   */
  public static final ObjectProperty COMPONENTS = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#components");

  public static final ObjectProperty COMPOSED_OF = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#composedOf");

  /**
   * <p>
   * A computed effect is a single expression that characterizes the effects of a composite process,
   * based on the effects of its sub processes. This is not well defined for conditional effects at
   * present.
   * </p>
   */
  public static final ObjectProperty COMPUTED_EFFECT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#computedEffect");

  /**
   * <p>
   * A computed input is a single expression that characterizes the inputs required by a composite
   * process, and the conditions under which they are required. This expression may, if needed, tie
   * together 2 or more inputs; for example,
   * "either a credit card number, or a bank account number must be given", or
   * "if product id starts with 'M', no shipping method need be given". Additionally, this
   * expression may refer to things other than inputs; for example; "if user's credit rating is
   * 'excellent' or better, Social Security number is not required", or
   * "if product weight is less than 1 lb., no shipping myth did need be given". A "computed" input
   * is so named because it is meant to be computed automatically by some tool, by inspecting the
   * makeup of the composite process. The language used to represent a computed input is not
   * specified here, and will be the subject of future work; hence, the use of Thing as range. It
   * will require expressiveness greater than that of OWL.
   * </p>
   */
  public static final ObjectProperty COMPUTED_INPUT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#computedInput");

  /**
   * <p>
   * A computed output is a single expression that characterizes the outputs required by a composite
   * process, and the conditions under which they are required. See comment for computedInput.
   * </p>
   */
  public static final ObjectProperty COMPUTED_OUTPUT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#computedOutput");

  /**
   * <p>
   * A computed precondition is a single expression that characterizes the preconditions of a
   * composite process, based on the preconditions of its sub processes.
   * </p>
   */
  public static final ObjectProperty COMPUTED_PRECONDITION = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#computedPrecondition");

  public static final ObjectProperty ELSE = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#else");

  /**
   * <p>
   * This is a deprecated usage; expandsTo is preferred.
   * </p>
   */
  public static final ObjectProperty EXPAND = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#expand");

  public static final ObjectProperty EXPANDS_TO = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#expandsTo");

  public static final ObjectProperty FROM_PROCESS = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#fromProcess");

  public static final ObjectProperty HAS_CLIENT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasClient");

  /**
   * <p>
   * This property has as range a Binding object, which may either indicate constants or values that
   * are derived from the parameters (typically outputs) of other performs in the SAME COMPOSITE
   * PROCESS.
   * </p>
   */
  public static final ObjectProperty HAS_DATA_FROM = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasDataFrom");

  public static final ObjectProperty HAS_EFFECT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasEffect");

  public static final ObjectProperty HAS_INPUT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasInput");

  public static final ObjectProperty HAS_LOCAL = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasLocal");

  public static final ObjectProperty HAS_OUTPUT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasOutput");

  public static final ObjectProperty HAS_PARAMETER = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasParameter");

  public static final ObjectProperty HAS_PARTICIPANT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasParticipant");

  public static final ObjectProperty HAS_PRECONDITION = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasPrecondition");

  public static final ObjectProperty HAS_RESULT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasResult");

  public static final ObjectProperty HAS_RESULT_VAR = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#hasResultVar");

  /**
   * <p>
   * The if condition of an if-then-else
   * </p>
   */
  public static final ObjectProperty IF_CONDITION = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#ifCondition");

  public static final ObjectProperty IN_CONDITION = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#inCondition");

  public static final ObjectProperty PERFORMED_BY = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#performedBy");

  public static final ObjectProperty PROCESS = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#process");

  public static final ObjectProperty PRODUCED_BINDING = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#producedBinding");

  public static final ObjectProperty REALIZED_BY = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#realizedBy");

  public static final ObjectProperty REALIZES = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#realizes");

  public static final ObjectProperty THE_VAR = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#theVar");

  public static final ObjectProperty THEN = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#then");

  /**
   * <p>
   * Interval of time allowed for completion of the process component (relative to the start of
   * process component execution).
   * </p>
   */
  public static final ObjectProperty TIMEOUT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#timeout");

  public static final ObjectProperty TO_PARAM = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#toParam");

  public static final ObjectProperty UNTIL_CONDITION = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#untilCondition");

  public static final ObjectProperty UNTIL_PROCESS = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#untilProcess");

  /**
   * <p>
   * This is the simplest kind of data flow
   * </p>
   */
  public static final ObjectProperty VALUE_SOURCE = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#valueSource");

  public static final ObjectProperty WHILE_CONDITION = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#whileCondition");

  public static final ObjectProperty WHILE_PROCESS = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#whileProcess");

  public static final ObjectProperty WITH_OUTPUT = m_model
      .createObjectProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#withOutput");

  /**
   * <p>
   * Invocable is a flag that tells whether the CompositeProcess bottoms out in atomic processes.
   * (If so, it is "invocable".)
   * </p>
   */
  public static final DatatypeProperty INVOCABLE = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#invocable");

  public static final DatatypeProperty NAME = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#name");

  public static final DatatypeProperty PARAMETER_TYPE = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#parameterType");

  /**
   * <p>
   * If an Input parameter has a constant value, or (as in the case of Output) is a description in
   * terms of of some other process parameters, then supply it here. Note that it must be
   * interpreted after reading it as an XMLLiteral. In future, the interpretation of this literal
   * may be extended to allow more flexibility, such as functional expressions.
   * </p>
   */
  public static final DatatypeProperty PARAMETER_VALUE = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#parameterValue");

  /**
   * <p>
   * valueData is for specifying constant (XML) data to be bound to a parameter. Ideally, the
   * valueData property would also be a subproperty of valueSpecifier so that it would be one of the
   * three possible properties used to specify a value for a Binding. But as we cannot do that, we
   * treat it separately, but note that if it is used, the others should not be. For now, its range
   * is any XML datatype.
   * </p>
   */
  public static final DatatypeProperty VALUE_DATA = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#valueData");

  /**
   * <p>
   * valueForm is to be used to specify an pseudo-OWL description that is legal OWL except that
   * variables (including process parameters) and ValueOf forms can appear as the object of
   * properties where those things violate the range of the property. The intent is that this be
   * interpreted as a pattern indicating the actual value of the binding after the variables have
   * been substituted for. A similar notation is used with valueFunction to indicate the application
   * of a locally (to the client) available function to convert data (specified by variables or
   * ValueOf) to a correct form.
   * </p>
   */
  public static final DatatypeProperty VALUE_FORM = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#valueForm");

  public static final DatatypeProperty VALUE_FUNCTION = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#valueFunction");

  public static final DatatypeProperty VALUE_SPECIFIER = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#valueSpecifier");

  public static final DatatypeProperty VALUE_TYPE = m_model
      .createDatatypeProperty("http://www.daml.org/services/owl-s/1.1/Process.owl#valueType");

  // Vocabulary classes
  // /////////////////////////

  /**
   * <p>
   * Allows the process components (specified as a bag) to be executed in some unspecified order but
   * not concurrently. Execution and completion of all components is required. The execution of
   * processes in an "Any-Order" construct cannot overlap, i.e.atomic processes cannot be executed
   * concurrently and composite processes cannot be interleaved.
   * </p>
   */
  public static final OntClass ANY_ORDER = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Any-Order");

  public static final OntClass ATOMIC_PROCESS = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#AtomicProcess");

  public static final OntClass BINDING = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Binding");

  /**
   * <p>
   * Choice calls for the execution of a single control construct from a given bag of control
   * constructs (given by the components property). Any of the given control constructs may be
   * chosen for execution.
   * </p>
   */
  public static final OntClass CHOICE = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Choice");

  /**
   * <p>
   * A CompositeProcess can have at most one invocable property. Similarly for computedInput,
   * computedOutput, computedEffect, and computedPrecondition.A CompositeProcess must have exactly 1
   * composedOf property.
   * </p>
   */
  public static final OntClass COMPOSITE_PROCESS = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#CompositeProcess");

  /**
   * <p>
   * Deprecated as of version 1.1
   * </p>
   */
  public static final OntClass CONDITIONAL_EFFECT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#ConditionalEffect");

  /**
   * <p>
   * Deprecated as of version 1.1
   * </p>
   */
  public static final OntClass CONDITIONAL_OUTPUT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#ConditionalOutput");

  /**
   * <p>
   * A ControlConstruct can have at most one instance of timeout.
   * </p>
   */
  public static final OntClass CONTROL_CONSTRUCT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#ControlConstruct");

  /**
   * <p>
   * A multiset of control constructs
   * </p>
   */
  public static final OntClass CONTROL_CONSTRUCT_BAG = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#ControlConstructBag");

  /**
   * <p>
   * OWL does not make any distinction between bags and lists. We redefine the ControlConstructList
   * class, rather than use equivalentClass, so as to make that distinction.
   * </p>
   */
  public static final OntClass CONTROL_CONSTRUCT_LIST = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#ControlConstructList");

  /**
   * <p>
   * If-Then-Else Class is a ControlConstruct that consists of a Condition, a then and an optional
   * else process.
   * </p>
   */
  public static final OntClass IF_THEN_ELSE = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#If-Then-Else");

  public static final OntClass INPUT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Input");

  /**
   * <p>
   * The subClassOf element is redundant, but we keep it because it is helpful to some tools
   * </p>
   */
  public static final OntClass INPUT_BINDING = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#InputBinding");

  /**
   * <p>
   * Iterate is an "abstract" class, in the sense that it's not detailed enough to be instantiated
   * in a process model. It's here to serve as the common superclass of Repeat-While, Repeat-Until,
   * and potentially other specific iteration constructs that might be needed in the future.
   * </p>
   */
  public static final OntClass ITERATE = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Iterate");

  /**
   * <p>
   * A Local parameter is a variable other than an input that is bound in a precondition of an
   * Atomic Process for use in a result condition or effect expression (or output expression) THEY
   * CANNOT BE USED IN COMPOSITE PROCESSES AT ALL. This avoids problems associated with state
   * sharing among asynchronously related sub processes.
   * </p>
   */
  public static final OntClass LOCAL = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Local");

  public static final OntClass OUTPUT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Output");

  /**
   * <p>
   * The subClassOf element is redundant, but we keep it because it is helpful to some tools
   * </p>
   */
  public static final OntClass OUTPUT_BINDING = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#OutputBinding");

  /**
   * <p>
   * This is the simplest way to relate parameters to SWRL (and DRS) variables.
   * </p>
   */
  public static final OntClass PARAMETER = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Parameter");

  public static final OntClass PARTICIPANT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Participant");

  /**
   * <p>
   * The PERFORM construct is how one references a process in a composite process. This is analogous
   * to a function call in a program body. The inputs to the PERFORM are described using the
   * hasDataFrom property.
   * </p>
   */
  public static final OntClass PERFORM = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Perform");

  /**
   * <p>
   * A Process can have at most one name, but names need not be unique.The most general class of
   * processes
   * </p>
   */
  public static final OntClass PROCESS_CLASS = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Process");

  /**
   * <p>
   * Deprecated as of v. 1.1. Note: the old concept ProcessComponent is no longer needed.
   * ControlConstruct which includes Perform as a subclass should be used anywhere that
   * ProcessComponent might have been used (which in the OWL-S 1.0 ontology was only in describing
   * the relationship to temporal aspects)
   * </p>
   */
  public static final OntClass PROCESS_COMPONENT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#ProcessComponent");

  public static final OntClass PRODUCE = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Produce");

  /**
   * <p>
   * The Repeat-Until class specializes the ControlConstruct class where the with properties
   * "untilCondition" (range of type Condition) and "untilProcess" (range of type Reapeat).
   * Repeat-Until does the operation, tests for the condition, exits if it is true, and otherwise
   * loops.
   * </p>
   */
  public static final OntClass REPEAT_UNTIL = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Repeat-Until");

  /**
   * <p>
   * The Repeat-While class specializes the ControlConstruct class where the with properties
   * "whileCondition" (range of type Condition) and ``whileProcess'' (range of type Repeat).
   * Repeat-While tests for the condition, exits if it is false and does the operation if the
   * condition is true, then loops.
   * </p>
   */
  public static final OntClass REPEAT_WHILE = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Repeat-While");

  public static final OntClass RESULT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Result");

  public static final OntClass RESULT_VAR = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#ResultVar");

  /**
   * <p>
   * Sequence is defined as having a list of component processes that specify the body. The
   * Preconditions, parameters and effects of the sequence are not defined in the minimal version.
   * An obvious extension would be to define the effect of the sequence to be the union of the
   * effect of the individual members, and the parameters of the sequence to be the union of the
   * parameters of individual members. However, some implementations may decide to use the last
   * event's effects as the effect of the sequence, etc.
   * </p>
   */
  public static final OntClass SEQUENCE = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Sequence");

  public static final OntClass SIMPLE_PROCESS = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#SimpleProcess");

  /**
   * <p>
   * Here the process consists of concurrent execution of a bunch of sub-processes. No further
   * specification about waiting, synchronization, etc. Similar to other ontologies' use of
   * "Concurrent" or "Parallel".
   * </p>
   */
  public static final OntClass SPLIT = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Split");

  /**
   * <p>
   * Here the process consists of concurrent execution of a bunch of sub-processes. with barrier
   * synchroniztion. With Split and Split and Join, we can define processes which have partial
   * synchronization (ex. split all and join some subset).
   * </p>
   */
  public static final OntClass SPLIT_JOIN = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Split-Join");

  /**
   * <p>
   * Deprecated. As of version 1.1, renamed to Any-Order.
   * </p>
   */
  public static final OntClass UNORDERED = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#Unordered");

  /**
   * <p>
   * We allow for the possibility that another parameter of the same process is referenced, in which
   * case this property is optional (hence maxCard)Within a value form, or when using valueSource,
   * references to parameters of other processes require a tuple of (perform-ref, param-ref, which
   * we represent with ValueOf
   * </p>
   */
  public static final OntClass VALUE_OF = m_model
      .createClass("http://www.daml.org/services/owl-s/1.1/Process.owl#ValueOf");

  // Vocabulary individuals
  // /////////////////////////

  public static final Individual THE_CLIENT = m_model.createIndividual(
      "http://www.daml.org/services/owl-s/1.1/Process.owl#TheClient", PARTICIPANT);

  /**
   * <p>
   * A special-purpose object, used to refer, at runtime, to the execution instance of the enclosing
   * composite process definition.
   * </p>
   */
  public static final Individual THE_PARENT_PERFORM = m_model.createIndividual(
      "http://www.daml.org/services/owl-s/1.1/Process.owl#TheParentPerform", PERFORM);

  public static final Individual THE_SERVER = m_model.createIndividual(
      "http://www.daml.org/services/owl-s/1.1/Process.owl#TheServer", PARTICIPANT);

  /**
   * <p>
   * A special-purpose object, used to refer, at runtime, to the execution instance of the enclosing
   * atomic process definition.
   * </p>
   */
  public static final Individual THIS_PERFORM = m_model.createIndividual(
      "http://www.daml.org/services/owl-s/1.1/Process.owl#ThisPerform", PERFORM);

}

/*
 * @footer@
 */

